	//observe that there are only so many combinations of x amount of 3" panels and y amount of 4.5" panels such that 3.0x + 4.5y = 48, if we fix x and y to be integers, this is a finite number, therefore there are at most 48/4.5 = 12 classes of these combinations. From these classes we can just permute the blocks to find all possible combinations. Therefore the greedy algorithm for subset-sum seems to be a good choice

class SumList{

	private:
		//each node in the linked list is a class of row types.
		struct node{
			int a;	// counter for blocks of type a
			int b;	// -----------"-------------- b
			node *next;
		} *p;

	public:
		SumList(){
			p = NULL;
		}

		void insert(int a1, int b1){
			//cout << a << 'b' << b1 << '\n';
			printf("@insert: %d and %d\n", a1, b1);
			if( p == NULL){
				p = new node;
				p->a = a1;
				p->b = b1;
				p->next = NULL;
			}
			else{
				node *q, *t;
				q = p;
				while(q->next != NULL)
					q = q->next;
				t = new node;
				t->a = a1;
				t->b = b1;
				t->next = NULL;
				q->next = t;			
			}
		}

		void print(){
			node* temp = p;
			while(temp != NULL){
				printf("@print: %d and %d\n", temp->a, temp->b);
				temp = temp->next;
			}
		}

		
};

SumList subset_sum_greedy(double a, double b, double s){
	//node* head = NULL;
	SumList list;
	for(int i = 0; i < 12; i++){
		double d_sum = s;
		d_sum = d_sum - (double)(i*a);
		//check if d_sum is divisible by b, if not continue in for loop
		if(fmod(d_sum, b)){
			continue;
		//else append to the linked list

		}

		printf("@subset: %d and %d\n", i, (int)(d_sum/b));
		list.insert(i, (int) (d_sum/b));
	}
	return list;

}
